<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        /*
            浅拷贝
                只是把  栈空间的 地址复制一份

            深拷贝
                无论对象里面有多少层对象，都要复制一份

                简单的写法：
                    JSON.parse(JSON.string(对象))

                复杂的写法：
                    递归

        */

        // let o1 = {
        //     name: '狗蛋',
        //     baba: {
        //         name: '狗子',
        //         yeye: {
        //             name: '二狗'
        //         }
        //     },
        //     mama: {

        //     }
        // }
        // 使用JSON序列化的方法
        // let o2 = JSON.parse(JSON.stringify(o1))
        // console.log(o2 === o1);
        // console.log(o2.baba === o1.baba);
        // console.log(o2.baba.yeye === o1.baba.yeye);


        // 递归
        // 先把 o1 这里面的不是对象的 部分复制
        // let o2 = {}
        // for (let key in o1) {
        //     o2[key] = o1[key]
        // }
        // o2.baba = {}
        // for (let key in o1.baba) {
        //     o2.baba[key] = o1.baba[key]
        // }
        // o2.baba.yeye = {}
        // for (let key in o1.baba.yeye) {
        //     o2.baba.yeye[key] = o1.baba.yeye[key]
        // }
        // console.log(o2);
        // console.log(o1 === o2);
        // console.log(o1.baba === o2.baba);
        // console.log(o1.baba.yeye === o2.baba.yeye);


        // 发现： 有规律，其实就是如果 某个属性不是对象，就直接复制
        // 如果是对象， 又要 遍历里面的 每个 键值对 再复制
        // let o1 = {
        //     name: '狗蛋',
        //     baba: {
        //         name: '狗子',
        //         yeye: {
        //             name: '二狗'
        //         }
        //     },
        //     mama: {
        //         name: '翠花'
        //     }
        // }

        // // 先复制第一层
        // let o2 = {}
        // for (let key in o1) {
        //     // 如果 key 对应 value 不是对象，直接复制
        //     if (typeof o1[key] !== 'object' || o1[key] === null) {
        //         o2[key] = o1[key]
        //     } else {
        //         // 如果 key 对应 value 是对象，我们再次遍历，再复制
        //         o2[key] = {}
        //         for (let key2 in o1[key]) {
        //             // o2[key][key2] = o1[key][key2]
        //             if (o1[key][key2] 是 对象) {
        //                 // 遍历
        //             }else {
        //                 // 不是对象，直接复制
        //                 o2[key][key2] = o1[key][key2]
        //             }
        //         }
        //     }
        // }
        // console.log(o2);
        // console.log(o2.baba === o1.baba);


        /*
            什么时候使用递归
                1. 复杂的
                2. 重复的，次数未知的
                3. 重得里面套重复
        */


        // 把深拷贝变成递归
        /*
            1. 先有一个函数，假设已经可以实现效果
        */
        function deepCopy(o1, o2) {
            for (let key in o1) {
                // 判断 o1[key] 是否对象
                if (typeof o1[key] === 'object' && o1[key] !== null) {
                    o2[key] = {}
                    deepCopy(o1[key], o2[key])
                } else {
                    o2[key] = o1[key]
                }
            }
        }


        let o1 = {
            name: '狗蛋',
            baba: {
                name: '狗子',
                yeye: {
                    name: '二狗'
                }
            },
            mama: {
                name: '翠花'
            }
        }

        let o2 = {}
        deepCopy(o1, o2)
        console.log(o1 === o2);
        console.log(o1.baba === o2.baba);
        console.log(o1.baba.yeye === o2.baba.yeye);
    </script>
</body>

</html>